// PLC服务接口
const API_BASE_URL = 'http://localhost:3002/api'; // PLC服务端口
const QUEUE_SERVICE_URL = 'http://localhost:3003/api'; // 队列服务端口

class PLCService {
  constructor() {
    this.monitoringVariables = new Map(); // 存储正在监控的变量
    this.monitoringInterval = null; // 监控定时器
    this.monitoringIntervalTime = 1000; // 监控间隔时间(毫秒)
    this.bulkReadThreshold = 10; // 批量读取阈值
    this.useQueueForMonitoring = false; // 监控是否使用队列服务
  }

  // 加载PLC配置
  async loadConfig() {
    try {
      console.log('🔄 正在加载PLC配置...');
      
      const response = await fetch(`${API_BASE_URL}/plc/config`);
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ PLC配置加载成功:', result);
      return result.config;
    } catch (err) {
      console.error('❌ PLC配置加载失败:', err);
      throw new Error(`PLC配置加载失败: ${err.message}`);
    }
  }

  // 加载PLC分组配置
  async loadGroups() {
    try {
      console.log('🔄 正在加载PLC分组配置...');
      
      const response = await fetch(`${API_BASE_URL}/plc/groups`);
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ PLC分组配置加载成功:', result);
      return result.groups;
    } catch (err) {
      console.error('❌ PLC分组配置加载失败:', err);
      throw new Error(`PLC分组配置加载失败: ${err.message}`);
    }
  }

  // 获取PLC状态
  async getStatus() {
    try {
      console.log('🔄 正在获取PLC状态...');
      
      const response = await fetch(`${API_BASE_URL}/plc/status`);
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ PLC状态获取成功:', result);
      return result;
    } catch (err) {
      console.error('❌ PLC状态获取失败:', err);
      throw new Error(`PLC状态获取失败: ${err.message}`);
    }
  }

  // 连接PLC
  async connect(config = null) {
    try {
      console.log('🔄 正在连接PLC...');
      
      const response = await fetch(`${API_BASE_URL}/plc/connect`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ config })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ PLC连接成功:', result);
      return result;
    } catch (err) {
      console.error('❌ PLC连接失败:', err);
      throw new Error(`PLC连接失败: ${err.message}`);
    }
  }

  // 断开PLC连接
  async disconnect() {
    try {
      console.log('🔄 正在断开PLC连接...');
      
      const response = await fetch(`${API_BASE_URL}/plc/disconnect`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        }
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ PLC断开连接成功:', result);
      return result;
    } catch (err) {
      console.error('❌ PLC断开连接失败:', err);
      throw new Error(`PLC断开连接失败: ${err.message}`);
    }
  }

  // 保存PLC配置
  async saveConfig(config) {
    try {
      console.log('🔄 正在保存PLC配置...');
      
      const response = await fetch(`${API_BASE_URL}/plc/save-config`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ config })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ PLC配置保存成功:', result);
      return result;
    } catch (err) {
      console.error('❌ PLC配置保存失败:', err);
      throw new Error(`PLC配置保存失败: ${err.message}`);
    }
  }

  // 直接读取PLC变量
  async _directReadVariables(variables) {
    try {
      console.log('🔄 直接读取PLC变量:', variables);
      
      // 由于已移除权限控制，直接使用标准接口
      const response = await fetch(`${API_BASE_URL}/plc/read`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ variables })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 直接读取PLC变量成功，原始响应:', result);
      
      // 确保返回完整的响应对象，包含success和values属性
      // 这样前端组件就可以正确识别成功状态和获取变量值
      if (typeof result === 'object' && result !== null) {
        // 如果后端已经返回了包含success和values的完整格式，直接返回
        if ('success' in result && 'values' in result) {
          return result;
        } 
        // 如果只有values或只有数据，构建完整格式
        else if ('values' in result) {
          return { ...result, success: true };
        }
        // 如果是纯数据对象，包装成标准格式
        else {
          return { success: true, values: result };
        }
      }
      
      // 处理意外情况
      return { success: true, values: {} };
    } catch (err) {
      console.error('❌ 直接读取PLC变量失败:', err);
      // 确保错误消息不为undefined
      const errorMessage = err.message || JSON.stringify(err) || '未知错误';
      throw new Error(`直接读取PLC变量失败: ${errorMessage}`);
    }
  }

  // 直接写入PLC变量
  async _directWriteVariable(variable, value) {
    try {
      console.log(`🔄 直接写入PLC变量: ${variable} = ${value}`);
      
      const response = await fetch(`${API_BASE_URL}/plc/write`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ variable, value })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 直接写入PLC变量成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 直接写入PLC变量失败:', err);
      throw new Error(`直接写入PLC变量失败: ${err.message}`);
    }
  }

  // 通过队列服务读取PLC变量
  async _queueReadVariables(variables) {
    try {
      console.log('🔄 通过队列服务读取PLC变量:', variables);
      
      const response = await fetch(`${QUEUE_SERVICE_URL}/queue/task`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          task: {
            type: 'plc-read',
            variables: variables
          }
        })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 通过队列服务读取PLC变量成功:', result);
      // 直接返回队列服务的结果，而不是再次调用直接读取
      return result;
    } catch (err) {
      console.error('❌ 通过队列服务读取PLC变量失败:', err);
      throw new Error(`通过队列服务读取PLC变量失败: ${err.message}`);
    }
  }

  // 读取PLC变量 - 简化版本（已移除权限控制）
  async readVariables(variables, options = {}) {
    const { useQueueService = false, batchSize = 100, useBulkMethod = false } = options;
    
    try {
      console.log('📥 读取PLC变量请求开始，变量数量:', variables.length, 
                  '使用队列服务:', useQueueService, '使用批量方法:', useBulkMethod);
      
      // 不自动切换，严格按照用户指定的方法调用
      if (useBulkMethod) {
        return await this.readBulkVariables(variables);
      }
      
      // 使用标准直接读取方式（已移除权限控制）
      const result = await this._directReadVariables(variables);
      
      // 确保返回格式符合前端组件期望
      // 如果result是对象且包含values属性，返回完整result对象（包含success和values）
      // 否则返回格式化的对象
      if (typeof result === 'object' && result !== null && 'values' in result) {
        // 后端返回的格式: { success: true, values: { 'DB1.W0.0': 1, ... } }
        console.log('✅ 读取变量成功，返回格式已确认:', { success: result.success, hasValues: !!result.values });
        return result;
      } else {
        // 处理可能的其他格式，确保返回标准格式
        console.log('⚠️ 读取变量返回非标准格式，转换为标准格式');
        return { success: true, values: result };
      }
    } catch (err) {
      console.error('❌ PLC变量读取失败:', err);
      // 确保错误消息不为undefined
      const errorMessage = err.message || JSON.stringify(err) || '未知错误';
      throw new Error(`读取PLC变量失败: ${errorMessage}`);
    }
  }

  // 直接读取PLC变量的便捷方法
  async readVariablesDirect(variables) {
    try {
      console.log('🔄 直接读取PLC变量:', variables);
      return await this._directReadVariables(variables);
    } catch (err) {
      console.error('❌ 直接读取PLC变量失败:', err);
      // 确保错误消息不为undefined
      const errorMessage = err.message || JSON.stringify(err) || '未知错误';
      throw new Error(`直接读取PLC变量失败: ${errorMessage}`);
    }
  }

  // 写入PLC变量 - 通过队列服务
  async writeVariable(variable, value) {
    try {
      console.log(`🔄 通过队列服务写入PLC变量: ${variable} = ${value}`);
      
      const response = await fetch(`${QUEUE_SERVICE_URL}/queue/task`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          task: {
            type: 'plc-write',
            variable: variable,
            value: value
          }
        })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 通过队列服务写入PLC变量成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 通过队列服务写入PLC变量失败:', err);
      throw new Error(`通过队列服务写入PLC变量失败: ${err.message}`);
    }
  }

  // 批量读取PLC变量的专用方法（已移除权限控制）
  async readBulkVariables(variables) {
    try {
      console.log('🔄 批量读取大量PLC变量:', variables.length);
      
      // 对于大量变量，直接调用PLC服务以提高性能
      return await this._directReadVariables(variables);
    } catch (err) {
      console.error('❌ 批量读取PLC变量失败:', err);
      // 确保错误消息不为undefined
      const errorMessage = err.message || JSON.stringify(err) || '未知错误';
      throw new Error(`批量读取PLC变量失败: ${errorMessage}`);
    }
  }

  // 读取分组变量
  async readGroupVariables(groupId) {
    try {
      console.log('🔄 读取PLC分组变量:', groupId);
      
      const response = await fetch(`${API_BASE_URL}/plc/read-group`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ groupId })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 读取PLC分组变量成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 读取PLC分组变量失败:', err);
      throw new Error(`读取PLC分组变量失败: ${err.message}`);
    }
  }

  // 写入分组变量
  async writeGroupVariable(groupId, variableName, value) {
    try {
      console.log(`🔄 写入PLC分组变量: ${groupId}.${variableName} = ${value}`);
      
      const response = await fetch(`${API_BASE_URL}/plc/write-group`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ groupId, variableName, value })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 写入PLC分组变量成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 写入PLC分组变量失败:', err);
      throw new Error(`写入PLC分组变量失败: ${err.message}`);
    }
  }

  // 加载所有分组配置 - 新增方法
  async loadAllGroups() {
    try {
      console.log('🔄 正在加载所有分组配置...');
      
      const response = await fetch(`${API_BASE_URL}/plc/load-groups`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        }
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 加载所有分组配置成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 加载所有分组配置失败:', err);
      throw new Error(`加载所有分组配置失败: ${err.message}`);
    }
  }

  // 加载指定分组配置 - 新增方法
  async loadGroup(groupId) {
    try {
      console.log(`🔄 正在加载分组配置: ${groupId}`);
      
      const response = await fetch(`${API_BASE_URL}/plc/load-group`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ groupId })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 加载分组配置成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 加载分组配置失败:', err);
      throw new Error(`加载分组配置失败: ${err.message}`);
    }
  }

  // 保存分组配置 - 新增方法
  async saveGroupConfig(groupId, groupConfig) {
    try {
      console.log(`🔄 正在保存分组配置: ${groupId}`);
      
      const response = await fetch(`${API_BASE_URL}/plc/save-group-config`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ groupId, groupConfig })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 保存分组配置成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 保存分组配置失败:', err);
      throw new Error(`保存分组配置失败: ${err.message}`);
    }
  }

  // 另存为分组配置 - 新增方法
  async saveAsGroupConfig(groupId, groupConfig) {
    try {
      console.log(`🔄 正在另存为分组配置: ${groupId}`);
      
      const response = await fetch(`${API_BASE_URL}/plc/save-as-group-config`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ groupId, groupConfig })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 另存为分组配置成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 另存为分组配置失败:', err);
      throw new Error(`另存为分组配置失败: ${err.message}`);
    }
  }

  // 删除分组配置 - 新增方法
  async deleteGroupConfig(groupId) {
    try {
      console.log(`🔄 正在删除分组配置: ${groupId}`);
      
      const response = await fetch(`${API_BASE_URL}/plc/delete-group-config`, {
        method: 'DELETE',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ groupId })
      });
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 删除分组配置成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 删除分组配置失败:', err);
      throw new Error(`删除分组配置失败: ${err.message}`);
    }
  }

  // 获取分组文件列表 - 新增方法
  async getGroupFiles() {
    try {
      console.log('🔄 正在获取分组文件列表...');
      
      const response = await fetch(`${API_BASE_URL}/plc/group-files`);
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ 获取分组文件列表成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 获取分组文件列表失败:', err);
      throw new Error(`获取分组文件列表失败: ${err.message}`);
    }
  }

  // 启动变量监控
  startMonitoring(variables, callback, intervalTime = 1000, useQueueService = false) {
    // 停止现有的监控
    this.stopMonitoring();
    
    // 设置监控间隔时间
    this.monitoringIntervalTime = intervalTime;
    
    // 设置监控是否使用队列服务
    this.useQueueForMonitoring = useQueueService;
    
    // 添加变量到监控列表
    variables.forEach(variable => {
      this.monitoringVariables.set(variable, { 
        lastValue: null, 
        callback: callback,
        errorCount: 0
      });
    });
    
    // 启动监控循环
    this._runMonitoringLoop();
    
    console.log(`✅ 启动PLC变量监控，监控 ${variables.length} 个变量，间隔 ${intervalTime}ms，使用${useQueueService ? '队列服务' : '直接访问'}`);
  }

  // 停止变量监控
  stopMonitoring() {
    if (this.monitoringInterval) {
      clearInterval(this.monitoringInterval);
      this.monitoringInterval = null;
    }
    
    this.monitoringVariables.clear();
    console.log('🛑 停止PLC变量监控');
  }

  // 添加变量到监控列表
  addMonitoringVariable(variable, callback) {
    this.monitoringVariables.set(variable, { 
      lastValue: null, 
      callback: callback,
      errorCount: 0
    });
    
    // 如果监控未启动，启动它
    if (!this.monitoringInterval) {
      this._runMonitoringLoop();
    }
    
    console.log(`➕ 添加变量到监控列表: ${variable}`);
  }

  // 从监控列表中移除变量
  removeMonitoringVariable(variable) {
    this.monitoringVariables.delete(variable);
    console.log(`➖ 从监控列表中移除变量: ${variable}`);
  }

  // 运行监控循环
  _runMonitoringLoop() {
    this.monitoringInterval = setInterval(async () => {
      if (this.monitoringVariables.size === 0) return;
      
      try {
        // 获取所有需要监控的变量名
        const variables = Array.from(this.monitoringVariables.keys());
        
        // 读取变量值
        let values;
        if (this.useQueueForMonitoring) {
          // 使用队列服务读取
          values = await this._queueReadVariables(variables);
        } else {
          // 直接读取PLC变量
          values = await this._directReadVariables(variables);
        }
        
        // 处理每个变量的值
        for (const variable of variables) {
          const variableInfo = this.monitoringVariables.get(variable);
          const newValue = values[variable];
          
          // 检查值是否发生变化
          if (variableInfo.lastValue !== newValue) {
            // 调用回调函数
            if (variableInfo.callback) {
              try {
                variableInfo.callback(variable, newValue, variableInfo.lastValue);
              } catch (err) {
                console.error(`❌ 监控变量回调执行失败 ${variable}:`, err);
              }
            }
            
            // 更新最后值
            variableInfo.lastValue = newValue;
            variableInfo.errorCount = 0; // 重置错误计数
          }
        }
      } catch (err) {
        console.error('❌ PLC监控循环执行失败:', err);
        
        // 增加错误计数，如果连续错误超过阈值则停止监控
        for (const [variable, info] of this.monitoringVariables.entries()) {
          info.errorCount++;
          if (info.errorCount > 5) {
            console.warn(`⚠️ 变量 ${variable} 连续错误超过阈值，从监控中移除`);
            this.monitoringVariables.delete(variable);
          }
        }
      }
    }, this.monitoringIntervalTime);
  }

  // 获取当前监控的变量列表
  getMonitoringVariables() {
    return Array.from(this.monitoringVariables.keys());
  }

  // 获取监控状态
  getMonitoringStatus() {
    return {
      isMonitoring: !!this.monitoringInterval,
      monitoredVariablesCount: this.monitoringVariables.size,
      intervalTime: this.monitoringIntervalTime,
      useQueueService: this.useQueueForMonitoring
    };
  }
  
  // 读取配置文件中的所有变量
  async readConfigVariables() {
    try {
      console.log('🔄 正在读取配置文件中的所有变量...');
      
      // 首先加载配置
      const config = await this.loadConfig();
      
      // 检查配置中是否有变量
      if (!config.variables || config.variables.length === 0) {
        console.log('⚠️ 配置文件中没有变量');
        return {};
      }
      
      // 提取变量地址
      const variableAddresses = config.variables.map(v => v.address);
      
      // 使用直接读取方式
      const result = await this.readVariablesDirect(variableAddresses);
      
      console.log('✅ 配置文件中的所有变量读取成功:', result);
      return result;
    } catch (err) {
      console.error('❌ 读取配置文件中的变量失败:', err);
      // 确保错误消息不为undefined
      const errorMessage = err.message || JSON.stringify(err) || '未知错误';
      throw new Error(`读取配置文件中的变量失败: ${errorMessage}`);
    }
  }

  // 获取PLC内部队列状态 - 新增方法
  async getQueueStatus() {
    try {
      console.log('🔄 正在获取PLC队列状态...');
      
      const response = await fetch(`${API_BASE_URL}/plc/queue-status`);
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ PLC队列状态获取成功:', result);
      return result.queueStatus;
    } catch (err) {
      console.error('❌ PLC队列状态获取失败:', err);
      throw new Error(`PLC队列状态获取失败: ${err.message}`);
    }
  }

  // 获取PLC内部队列历史记录 - 新增方法
  async getQueueHistory() {
    try {
      console.log('🔄 正在获取PLC队列历史记录...');
      
      const response = await fetch(`${API_BASE_URL}/plc/queue-history`);
      
      if (!response.ok) {
        // 尝试从错误响应中获取详细错误信息
        try {
          const errorData = await response.json();
          // 使用后端返回的错误消息
          throw new Error(errorData.message || errorData.error || `HTTP error! status: ${response.status}`);
        } catch (jsonError) {
          // 如果无法解析JSON，使用基本HTTP错误
          throw new Error(`HTTP error! status: ${response.status}`);
        }
      }
      
      const result = await response.json();
      console.log('✅ PLC队列历史记录获取成功:', result);
      return result.queueHistory;
    } catch (err) {
      console.error('❌ PLC队列历史记录获取失败:', err);
      throw new Error(`PLC队列历史记录获取失败: ${err.message}`);
    }
  }
}

export default new PLCService();